import java.util.*;
/**
 * 链表反转
 * 将单链表反转，返回反转后的链表头节点
 * 使用迭代方法实现，时间复杂度O(n)，空间复杂度O(1)
 */
public class reverseList {
    /**
     * 链表节点类
     * 包含节点值和指向下一个节点的引用
     */
    public static class ListNode{
        int val;        // 节点值
        ListNode next;  // 指向下一个节点的引用
        
        // 无参构造函数
        ListNode(){}
        
        // 带值的构造函数
        ListNode(int val){
            this.val = val;
        }
        
        // 带值和下一个节点的构造函数
        ListNode(int val, ListNode next){
            this.val = val;
            this.next = next;
        }
    }

    /**
     * 反转链表的方法
     * 算法步骤：
     * 1. 使用三个指针：pre(前一个节点)、head(当前节点)、tmp(下一个节点)
     * 2. 每次迭代：
     *    - 保存下一个节点
     *    - 反转当前节点的指向
     *    - 移动pre和head指针
     * @param head 链表头节点
     * @return 反转后的链表头节点
     */
    public static ListNode reverseListM(ListNode head){
        // 处理空链表的情况
        if(head == null) return null;
        
        ListNode pre = null;  // 前一个节点，初始为null
        while(head != null){
            ListNode tmp = head.next;  // 保存下一个节点
            head.next = pre;          // 反转当前节点的指向
            pre = head;               // 移动pre指针
            head = tmp;               // 移动head指针
        }
        return pre;  // 返回反转后的头节点
    }

    /**
     * 主函数：处理输入输出
     * 从控制台读取链表节点值，反转后输出
     */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        // 读取链表节点值
        String[] s = sc.nextLine().split(" ");
        
        // 创建链表
        ListNode dummy = new ListNode(0);  // 虚拟头节点
        ListNode node = dummy;
        for(int i = 0; i < s.length; i++){
            node.next = new ListNode(Integer.parseInt(s[i]));
            node = node.next;
        }
        
        // 反转链表并输出结果
        ListNode result = reverseListM(dummy.next);
        while(result != null){
            System.out.print(result.val + " ");
            result = result.next;
        }
        sc.close();
    }
}
